/*
 * Copyright kecp
 * Apr 24, 2010
 */

package Tool;


import java.io.UnsupportedEncodingException;

/**
 *工具类，提供字节数值等基本类型的转换
 * @author kecp
 */
public class Toolkit {

      

       /**
        * 把字符串转化为UTF-8编码格式的字节数组
        * @param str 要进行转换的字符串
        * @return 转换后的字符串,如不支持UTF-8编码格式则返回null
        */
      public static byte[] stringToUtfBytes(String str){
         byte buffer[] = null;
        try {
            buffer = str.getBytes("UTF-8");
        } catch (UnsupportedEncodingException ex) {
            ex.printStackTrace();

            return null;
        }
          return buffer;
      }


      /**
       * 将UTF-8编码格式的字节数组转换为字符串
       * @param buffer 字节数组
       * @param offset 要进行转换的开始偏移
       * @param length 指定长度
       * @return 字符串
       */
      public static String utfBytesToString( byte []buffer,int offset , int length){
            String str = null;
            try {
                str = new String(buffer, offset, length, "UTF-8");
            } catch (UnsupportedEncodingException ex) {
                ex.printStackTrace();
            }
                return str;
      }


      /**
       * 将UTF-8编码格式的整个字节数组转换为字符串
       * @param buffer 字节数组
       * @return 字符串
       */
      public static String utfBytesToString( byte []buffer ){
            String str = null;
            if( buffer == null )
                return null;
            try {
                str = new String(buffer, "UTF-8");
            } catch (UnsupportedEncodingException ex) {
                ex.printStackTrace();
            }
                return str;
      }

 
      /**
       * 将一个四字节的int型转换为对应的字节数组,低字节优先存储,如低8位存放在数组中的第一个字节中
       * @param i 要进行转换的int
       * @return 4字节数组,存放着参数的int值
       */
       public static byte[] intToBytes ( int i ){
            byte intb[] = new byte[4];

            intb[0]=(byte)(i&0xff);
            intb[1]=(byte)(i>>8&0xff);
            intb[2]=(byte)(i>>16&0xff);
            intb[3]=(byte)(i>>24&0xff);
            return intb;
            
      }
      /**
       * 将一个int值存放到数组的指定位置中,按int值中的低字节优先存储
       * @param i int值
       * @param intb 存放int值的数组
       * @param offset 指定要把int值存放到intb的具体偏移位置
       * @return  如果数组空间不够则返回false,否则写进数据并返回true
       */
       public static boolean  intToBytes( int i, byte intb[], int offset){

           if( intb.length - offset <4 )
               return false;
            intb[offset]=(byte)(i&0xff);
            intb[offset+1]=(byte)(i>>8&0xff);
            intb[offset+2]=(byte)(i>>16&0xff);
            intb[offset+3]=(byte)(i>>24&0xff);
            return true;
          
       }

       public static boolean shortToBytes( short i, byte shortb[], int offset ) {
           if( shortb.length - offset<4)
               return false;
           shortb[offset]=(byte)(i&0xff);
           shortb[offset+1] = (byte)(i>>8&0xff);
           return true;
       }

       public static short bytesToShort( byte bs[] , int offset ) {
           if( bs.length - offset <2 )
               return -1;
           short i;
             i = bs[offset+1];
             i <<= 8;
             i |= bs[offset]&0xff;
             return i;
       }


         /**
        * 将字节数组的指定位置的四个字节转换为一个int值
        * @param bs 字节数组
        * @param offset 进行转换的数组偏移
        * @return 转换后的int值,如果数组长度不够4个字节转换,则固定返回-1
        */
      public static int bytesToInt( byte bs[] , int offset ){
            if( bs.length - offset < 4)
                return -1;
            int i=0;
              i = bs[offset+3];
              i <<= 8;
              i |= bs[offset+2]&0xff;
              i <<= 8;
              i |= bs[offset+1]&0xff;
              i <<= 8;
              i |= bs[offset]&0xff;
              return i;


      }


       /**
        * 将字节数组中指定位置的两个字节转换为一个字符
        * @param bs 字节数组
        * @param offset 指定要转换的偏移
        * @return 转换后的字符,当数组长度够两个字节进行转换时,则固定返回0
        */
       public static char bytesToChar( byte bs[], int offset ){
           if( bs.length - offset <2 )
               return 0;
           char ch;
           ch =  (char) bs[offset];
           ch<<=8;
           ch|= bs[offset+1]&0xff;
           return ch;
       }
       




      /**
       * 从一个蓝牙服务url中解析出提供该服务的蓝牙地址的字符串
       * @param url 蓝牙服务url
       * @return 蓝牙地址字符串
       */
        static public String getMac (String url){
       int a = url.indexOf("//");
       int b = url.indexOf(":", a);
       return url.substring(a+2, b);

    }

    /**
     * 从一个文件url中解析出文件名,如file://c/file1.txt则返回file1.txt
     * @param url 文件url
     * @return 文件名字
     */
    static public String getFileName (String url){
       int i = 0;
       int length = url.length();
       char c = '/';
       //查找url中最后一个'/'
       int index = 0;
       for( ; i<length; i++){
           if( url.charAt(i) == c ){
               index = i;
           }
       }
       return url.substring(index+1);
    }


      /**
  * 字节数组转换为十六进制字符串
  * @param datas byte[] 待转换数据
  * @param sign String 十六进制前置标识,如"0x"或 “%”, 如 null 或 "" 则不加
  * @return String 已转换数据
  */
public  static String bytes2HexString(byte[] datas, String sign) {
    StringBuffer sb = new StringBuffer("");
    int n = datas.length;

    for( int j=0 ; j< n; j++ ) {

        int i = datas[j] & 0xFF;//byte类型【8位】转换为int类型【32位】
        String hex = Integer.toHexString(i);

        if (hex.length() == 1) {
            hex = '0' + hex;
        }
        if( sign != null )
            hex = sign + hex;
        sb.append(hex.toUpperCase());
    }
    return sb.toString();
}

 /**
  * 把utf8编码的字符串转换为使用十六进制表示的字符串
  * @param zn String 待转换数据
  * @param sign String 十六进制前置标识,如"0x"或 “%”, 如 null 或 "" 则不加
  * @return String 已转换数据
  */
 public  static String utf8StrEncToHexStr(String zn , String sign ){
        byte []buffer = null;
        String hexStr = null;
        try {
            buffer = zn.getBytes("UTF-8");
            hexStr =bytes2HexString(buffer,sign);
        } catch (UnsupportedEncodingException ex) {
           return null;
        }
        return hexStr;
    }


}
